home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C++ / Frameworks / Sprocket Framework DR2 / Sprocket Framework / DynamicArray.cp < prev    next >
Text File  |  1996-06-15  |  4KB  |  204 lines
  1. /*
  2.  
  3.     File:        DynamicArray.cp
  4.     Project:    Sprocket Framework 1.1 (DR2), released 6/15/96
  5.     Contains:    Array class which adjusts size dynamically
  6.     To Do:        ?
  7.  
  8.     Sprocket Major Contributors:
  9.     ----------------------------
  10.     Dave Falkenburg, producer of Sprocket 1.0
  11.     Bill Hayden,     producer of Sprocket 1.1
  12.     Steve Sisak,     producer of the upcoming Sprocket 2.0
  13.     
  14.     Pete Alexander        Steve Falkenburg    Randy Thelen
  15.     Eric Berdahl        Nitin Ganatra        Chris K. Thomas
  16.     Marshall Clow        Dave Hershey        Leonard Rosenthal
  17.     Tim Craycroft        Dave Mark            Dean Yu
  18.     David denBoer        Gary Powell
  19.     Cameron Esfahani    Jon Summers            Apple Computer, Inc.
  20.         
  21.     Comments, Additions, or Corrections:
  22.     ------------------------------------
  23.     Bill Hayden, Nikol Software <nikol@codewell.com>
  24.  
  25. */
  26.  
  27.  
  28.  
  29. #include "DynamicArray.h"
  30. #include <Memory.h>
  31. #include <Errors.h>
  32.  
  33. TDynamicArray::TDynamicArray()
  34. {
  35.     fElementCount = 0;
  36.     fStorage = (ArrayElementPtr **) NewHandle(0);
  37. }
  38.     
  39.  
  40. TDynamicArray::~TDynamicArray()
  41. {
  42.     DisposeHandle((Handle) fStorage);
  43. }
  44.     
  45.  
  46. OSErr
  47. TDynamicArray::Insert(ArrayElement * elementToInsert, ArrayElementIndex beforeElement)
  48. {
  49.     OSErr    err;
  50.     
  51.     //    make room for one more ArrayElementPtr
  52.     SetHandleSize((Handle) fStorage, fElementCount*sizeof(ArrayElementPtr) + sizeof(ArrayElementPtr));
  53.     if ((err = MemError()) != noErr)
  54.         return err;
  55.     
  56.     //    slide remaining elements down
  57.     BlockMoveData(    &((*fStorage)[beforeElement]),
  58.                     &((*fStorage)[beforeElement+1]),
  59.                     (fElementCount - beforeElement) * sizeof(ArrayElementPtr));
  60.     
  61.     fElementCount++;
  62.     (*fStorage)[beforeElement] = elementToInsert;
  63.  
  64.     return noErr;
  65. }
  66.  
  67.  
  68. OSErr
  69. TDynamicArray::InsertFirst(ArrayElement * elementToInsert)
  70. {
  71.     return this->Insert(elementToInsert, 0);
  72. }
  73.  
  74.  
  75. OSErr
  76. TDynamicArray::InsertLast(ArrayElement * elementToInsert)
  77. {
  78.     return this->Insert(elementToInsert, fElementCount);
  79. }
  80.  
  81.  
  82. OSErr TDynamicArray::Delete(ArrayElementIndex whichElement)
  83. {
  84.     //    slide remaining elements up
  85.     BlockMoveData(    &((*fStorage)[whichElement+1]),
  86.                     &((*fStorage)[whichElement]),
  87.                     (fElementCount - whichElement) * sizeof(ArrayElementPtr));
  88.  
  89.     //    cut back the storage
  90.     fElementCount--;
  91.     SetHandleSize((Handle) fStorage,fElementCount*sizeof(ArrayElementPtr));
  92.     return MemError();
  93. }
  94.  
  95.  
  96. OSErr TDynamicArray::DeleteFirst()
  97. {
  98.     return this->Delete(0);
  99. }
  100.  
  101.  
  102. OSErr TDynamicArray::DeleteLast()
  103. {
  104.     return this->Delete(fElementCount);
  105. }
  106.  
  107.  
  108. ArrayElementPtr TDynamicArray::GetIndexedElement(ArrayElementIndex whichElement)
  109. {
  110.     return (*fStorage)[whichElement];
  111. }
  112.     
  113.  
  114. void TDynamicArray::SetIndexedElement(ArrayElementIndex whichElement, ArrayElementPtr element)
  115. {
  116.     (*fStorage)[whichElement] = element;
  117. }
  118.  
  119.  
  120. void TDynamicArray::ForEachElement(EachArrayElementProc proc, void * param)
  121. {
  122.     ArrayElementIndex    index = 0;
  123.     
  124.     while (index < fElementCount)
  125.         {
  126.         (*proc)((*fStorage)[index], param);
  127.         index++;
  128.         }
  129. }
  130.  
  131.  
  132. ArrayElementPtr TDynamicArray::FirstElementThat(EachArrayElementTestProc proc, void * param)
  133. {
  134.     ArrayElementIndex    index = 0;
  135.     
  136.     while (index < fElementCount)
  137.         {
  138.         if ((*proc)((*fStorage)[index], param))
  139.             return (*fStorage)[index];
  140.         index++;
  141.         }
  142.  
  143.     return NULL;
  144. }
  145.  
  146.  
  147. ArrayElementPtr TDynamicArray::LastElementThat(EachArrayElementTestProc proc, void * param)
  148. {
  149.     ArrayElementIndex    index = fElementCount-1;
  150.     
  151.     while (index != -1)
  152.         {
  153.         if ((*proc)((*fStorage)[index], param))
  154.             return (*fStorage)[index];
  155.         index--;
  156.         }
  157.  
  158.     return NULL;
  159. }
  160.     
  161.     
  162.     
  163. OSErr TDynamicArray::FindAndDeleteElement(ArrayElementPtr element)
  164. {
  165.     ArrayElementIndex    index = 0;
  166.     OSErr                err = userDataItemNotFound;
  167.     
  168.     while (index < fElementCount)
  169.         {
  170.         if ( (*fStorage)[index] == element )
  171.             {
  172.             err = this->Delete(index);
  173.             break;
  174.             }
  175.             
  176.         index++;
  177.         }
  178.         
  179.     return err;
  180. }
  181.  
  182.  
  183.  
  184. OSErr    TDynamicArray::MoveToFront(ArrayElementPtr elementToMove)
  185. {
  186.     ArrayElementIndex index;
  187.  
  188.     for (index = 0; index < fElementCount; index++)
  189.         {
  190.         if (elementToMove == (*fStorage)[index])
  191.             {
  192.             if (index != 0)
  193.                 {
  194.                 BlockMoveData(&(*fStorage)[0], &(*fStorage)[1], index * sizeof(ArrayElementPtr));
  195.                 (*fStorage)[0] = elementToMove;
  196.                 }
  197.                 
  198.             return noErr;
  199.             }
  200.         }
  201.  
  202.     return userDataItemNotFound;
  203. }
  204.